package writtenTraining.day40;

import java.util.*;

/**
 * day40:(1)枚举:游游的字母串
 */


 class Main {
    public static void main(String[] args) {
        // 枚举 26 个字母
        // 输入数据
        Scanner in =new Scanner(System.in);
        char[] chs = in.next().toCharArray();
        int len = chs.length;

        // 确立基准
        int ret = 0x3f3f3f3f;
        for(int i = 0; i < 26; i++) {
            char ch = (char)('a' + i);
            int count = 0;
            for(int j = 0; j < len; j++) {
                int num1 = Math.abs(chs[j]- ch);
                int num2 = 26 - num1;
                count += Math.min(num1,num2);
            }

            ret = Math.min(count,ret);
        }

        // 输出结果
        System.out.println(ret);
    }
}
/**
 * day40:(2)拓扑排序+ 广度优先遍历：NC316 体育课测验(二)
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numProject int整型 
     * @param groups int整型ArrayList<ArrayList<>> 
     * @return int整型ArrayList
     */
    public ArrayList<Integer> findOrder (int numProject, ArrayList<ArrayList<Integer>> groups) {
        // 拓扑排序 + bfs

        int[] vim = new int[numProject];

        // 构建图

        // 建立入度和出度的关系
        Map<Integer,List<Integer>> map = new HashMap<>();
        int len = groups.size();
        // 进行入度
        for(int i = 0; i < len; i++) {
            int num1 = groups.get(i).get(1), num2 = groups.get(i).get(0);
            vim[num2]++;
            if(!map.containsKey(num1)) {
                map.put(num1,new ArrayList<Integer>());
            }

            map.get(num1).add(num2);
        }

        Queue<Integer> queue = new LinkedList<>();
        ArrayList<Integer> ret = new ArrayList<>();

        // 将度不为 0 的加入到队列中
        for(int i = 0 ; i < numProject; i++) {
            if(vim[i] == 0) {
                queue.add(i);
            } 
        }

        // 进行广度优先遍历
        while(!queue.isEmpty()) {
          int  sz = queue.size();
            for(int i =0; i < sz; i++) {
                int tar = queue.poll();
                // 加入结果
                ret.add(tar);
                for(int num : map.getOrDefault(tar,new ArrayList<>())) {
                    vim[num]--;
                    // 一旦度为 0 就继续加入到队列中
                    // 观察他的出度是否存在
                    if(vim[num] <= 0) {
                        queue.add(num);
                    }
                }
            }
        }

        return (ret.size() != numProject ? new ArrayList<Integer>() : ret);
    }
}


/**
 * day40:(3)动态规划+最长递增子序列+ 最长递减子序列：DP16 合唱队形
 */

// 注意类名必须为 Main, 不要有任何 package xxx 信息
 class Main3 {
    public static void main(String[] args) {
        // 动态规划 + 最长递增子序列 + 从后往前的最长递减子序列
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        int[] nums = new int[n];
        for(int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
        }


        // 先统计最长递增子序列
        int[] dp = new int[n];
        Arrays.fill(dp,1);
        for(int i = 1; i < n; i++) {
            for(int j = 0 ; j < i; j++) {
                if(nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i],dp[j] + 1);
                }
            }
        }

        // 然后统计最长递减子序列
        int[] gp = new int[n];
        Arrays.fill(gp,1);
        for(int i = n - 2; i >= 0 ; i--) {
            for(int j = n - 1 ; j > i ; j--) {
                if(nums[i] > nums[j]) {
                    gp[i] = Math.max(gp[i],gp[j] + 1);
                }
            }
        }

        // 其中最长的长度
        int ret = -0x3f3f3f3f;
        for(int i = 0 ; i < n; i++) {
            // 统计前面是递增 + 后面递减 - 1
            ret = Math.max(ret,dp[i] + gp[i] - 1);
        }

        // 输出结果
        System.out.println(n - ret);
    }
}